EnigmA Amiga Run 1995 November/EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso/earcd/program/misc/bgui12.lha/docs/windowclass.doc

Text File | 1995-09-09 | 28KB | 927 lines

           File: windowclass.doc
    Description: Windowclass documentation.
      Copyright: (C) Copyright 1994-1995 Jaba Development.
             (C) Copyright 1994-1995 Jan van den Baard.
             All Rights Reserved.

------------------------------------------------------------------------------

TABLE OF CONTENTS

windowclass/--background--
windowclass/Methods
windowclass/Attributes

windowclass/--background--                windowclass/--background--

    NAME
    Class:        windowclass
    Superclass:    ROOTCLASS
    Include File:    <libraries/bgui.h>

    FUNCTION
    To  provide  an  easy  to use BGUI interface to intuition windows. The
    window    class  provides just about anything you need to create windows
    with a fully font sensitive and size adjustable GUI.

windowclass/Methods                       windowclass/Methods

    NEW METHODS
    WM_OPEN -- This method must be used to open the window.  When a window
        object is created it does not open right away.

        Returns a pointer to the opened window uppon success  and NULL
        uppon failure.

    WM_CLOSE -- This method must be used to close the window again.  It is
        safe to call this method even when the window is not open.

        Returns TRUE uppon success and FALSE uppon failure.

    WM_SLEEP -- With this method you can put your window to sleep  when it
        is  open.   This  is  done  by    setting  up a  small invisible
        requester and a busy pointer.

        Returns TRUE uppon success and FALSE uppon failure.

    WM_WAKEUP -- This methos must be  used to  wake  up the  window again.
        Please note that you must wake up the window as many  times as
        you have put it to sleep before you can actually use it again.
        Both the WM_SLEEP and WM_WAKEUP methods can be nested.

        Returns TRUE uppon success and FALSE uppon failure.

    WM_HANDLEIDCMP -- This method must be  used  to call  the  windowclass
        event handler. The event handler will  act  uppon the messages
        present at the window it's message  port  and  return  you one
        of the following return codes:

        WMHI_CLOSEWINDOW -- The window it's close gadget was selected.
        WMHI_NOMORE -- No more messages waiting.
        WMHI_INACTIVE -- The window was de-activated.
        WMHI_ACTIVE -- The window was activated.
        WMHI_IGNORE -- Ignore this result.

        Any return code which differs from the ones  above is  the  ID
        of a selected object (gadget or menu).

        Please look at the demo programs for more information.

    WM_GADGETKEY -- With this method you  can  assign a  key to  trigger a
        gadget object in the window.  This method  uses the  following
        custom message structure:

        struct wmGadgetKey {
            ULONG          MethodID;  /* WM_GADGETKEY */
            struct Requester *wmgk_Requester;
            Object         *wmgk_Object;
            STRPTR          wmgk_Key;
        };

        wmgk_Requester -- This version of the library does not support
            BGUI gadget objects in requesters  so this  field must
            be set to NULL.

        wmgk_Object -- This must be  a    pointer to  the  object  which
            must be controlled by the key.

        wmgk_Key -- This must point to a  string  in   which  a single
            character is located. The character is    the  key which
            controls the object when it is pressed.

        Returns TRUE uppon success and FALSE uppon failure.

    WM_KEYACTIVE, WM_KEYINPUT, WM_KEY_INACTIVE -- These three  methods are
        sent to the gadget object during a key-session.  Please  refer
        to the "methods.doc" file for more information.

    WM_DISABLEMENU, WM_CHECKITEM -- These  two  methods  must  be  used to
        disable or enable a menu or a menu item or to set or clear the
        check mark of a CHECKIT item.    These  methods    both  use  the
        following custom message structure:

        struct wmMenuAction {
            ULONG          MethodID; /* Any of the above. */
            ULONG          wmma_MenuID;
            ULONG          wmma_Set;
        };

        wmma_MenuID -- This must be the ID of the  menu/item  on which
            the operation is done. The ID is  the value  which you
            set in the nm_UserData field of the NewMenu structure.

        wmma_Set -- This is a boolean which  disables/checks  the menu
            when set to  TRUE  or  enables/unchecks the  menu when
            set to FALSE.

        Returns TRUE uppon success and FALSE uppon failure.

    WM_MENUDISABLED, WM_ITEMCHECKED -- These two methods  must  be used to
        query about the disabled/checked state of a menu. Both methods
        use the following custom message structure:

        struct wmMenuQuery {
            ULONG          MethodID; /* Any of the above. */
            ULONG          wmmq_MenuID;
        };

        wmmq_MenuID -- This must be the ID of the  menu/item  on which
            the operation is done. The ID is  the value  which you
            set in the nm_UserData field of the NewMenu structure.

        Returns TRUE if the menu is disabled/checked and FALSE if not.
        A return code of ~0 means that the menu is unknown or no menus
        are available.

    WM_TABCYCLE_ORDER -- With this method you can  determine the  order of
        tab-cycling.  This method uses    the  following    custom message
        structure:

        struct wmTabCycleOrder {
            ULONG          MethodID; /* WM_TABCYCLE_ORDER */
            Object         *wtco_Object1;
            /* Object     *wtco_Object2; */
            /* ... */
            /* NULL */
        };

        wtco_Object1 -- The first of a the objects which  will be  set
            in the tab-cycle chain.   Please  note    that you  must
            terminate the method with a NULL pointer.

        Returns TRUE uppon success and FALSE uppon failure.

    WM_GETAPPMSG -- This method must be used  to get the AppWindow message
        when one is available.    Please note that _you_ are  resposible
        for replying the message.

        Returns a pointer to the AppMessage or NULL when  there was no
        message.

    WM_ADDUPDATE -- This method must be used  to  perform  simple map-list
        notification with  externalclass  objects.  The  externalclass
        objects are not able to perform  notification  like  the other
        gadget classes. This method uses the  following custom message
        structure:

        struct wmAddUpdate {
            ULONG          MethodID; /* WM_ADDUPDATE */
            ULONG          wmau_SourceID;
            Object         *wmau_Target;
            struct TagItem     *wmau_MapList;
        };

        wmau_SourceID -- This must be the ID of the object that send's
            the notification message.

        wmau_Target -- This must be a  pointer    to  the  object  which
            must be updated by the notiication.

        wmau_MapList -- This can pointe to  an    array  of  tags  which
            contain the attributes to map.    This may also  be NULL
            in which case no mapping is done.

        Return TRUE uppon success and FALSE uppon failure.

    WM_REPORT_ID ** V38 ** -- This method  will  allow  an    IDCMP-hook  or
        Verify-hook to report ID's  to  the  application program.   It
        will  stack  the  ID(s)  to  report  and  pass    them  to   the
        application the next time the WM_HANDLEIDCMP method is called.
        This  method  uses the following custom message structure:

        struct wmReportID {
            ULONG        MethodID;    /* WM_REPORT_ID     */
            ULONG        wmri_ID;
            ULONG        wmri_Flags;
        };

        wmri_ID -- This is the ID that is put on the stack.  Next time
            the application  call's  WM_HANDLEIDCMP on  the object
            the ID's on the stack are returned.

        wmri_Flags -- This may contain any of the following flags:

            WMRIF_DOUBLE_CLICK -- When this flag is set  the ID to
                report     is  put  on  the  stack  twice  which
                effectivly simulates a double-click.

        Returns TRUE uppon success and FALSE uppon failure.

    WM_GET_SIGNAL_WINDOW ** V39 ** -- This method is  only    useful    if you
        one message port for several window.    When  your  program is
        signalled that a message has  arrived  at the  shared  message
        port you must use this method to determine  from  which window
        the message originated so that you may call uppon the  correct
        event handler.

        It  does  not  matter  from  which window object that uses the
        shared    message  port you get this information just as long as
        the object uses the shared message port.

        Example:

        struct MsgPort *mp;
        Object           *WO_Win1, *WO_Win2, *WO_Win3;
        struct Window  *Win1, *Win2, *Win3, *SigWin;

        do {
            Wait( 1 << mp->mp_SigBit );

            while ( SigWin = DoMethod( WO_Win1,
                        WM_GET_SIGNAL_WINDOW )) {

                if ( SigWin == Win1 ) {
                    /* Handle events WO_Win1 */
                    ...
                }

                if ( SigWin == Win2 ) {
                    /* Handle events WO_Win2 */
                    ...
                }

                if ( SigWin == Win3 ) {
                    /* Handle events WO_Win3 */
                    ...
                }
            }
        } while ( ... );

        Please take a look at  the  "BGUIDemo"  demonstration  program
        to see a working implementation.

        Returns  a  pointer  to  the  window  from  which  the    signal
        originated or NULL if the window could not be found.

    CHANGED METHODS
    OM_DISPOSE -- When  this  method is called all objects attached to the
        window with the WINDOW_MasterGroup attribute are also disposed
        of.

windowclass/Attributes                    windowclass/Attributes

    NAME
    WINDOW_Position -- ( ULONG )

    FUNCTION
    To determine the position at which the window is opened. These are the
    possibilities:

    POS_CENTERSCREEN -- The window is centered in the visible part    of the
        screen it is opened on.
    POS_CENTERMOUSE -- The window is centered under  the mouse.  Depending
        on the location of the mouse this might differ a little.
    POS_TOPLEFT -- The window is opened  at  the  top-left    corner    in the
        visible part of the screen it is opened on.

    Default is POS_CENTERSCREEN. Applicability is (I).

    SEE ALSO
    WINDOW_PosRelBox

    NAME
    WINDOW_ScaleWidth, WINDOW_ScaleHeight -- ( ULONG )

    FUNCTION
    To open a window larger than it's minimum size. The data you pass with
    these tags must be the percentage (0%..100%) of the  visible  size  of
    the screen minus the minimum size of the window.  For example you have
    a  window which is 100 pixels wide at it's minimum size  on  a  screen
    which    is  1000   pixels   wide   (visible)   and   you  pass    25  as
    WINDOW_ScaleWidth  the window is opened 325 pixels wide.

    (( 1000 - 100 ) / 100 ) * 25 = 225

    225 + 100 = 325

    Defaults are 0. Applicability is (I).

    NAME
    WINDOW_LockWidth, WINDOW_LockHeight -- ( BOOL )

    FUNCTION
    To disable sizing the width or height of a window.

    Defaults are FALSE. Applicability is (I).

    NAME
    WINDOW_PosRelBox -- ( struct IBox * )

    FUNCTION
    To open the window centered in the described box.  The    data  you pass
    here must be a pointer to a struct IBox in which the location and size
    of the box is described. This will allow you to easely center a window
    uppon another window like this:

    struct Window        *parent;
    struct IBox         position;
    Object            *window_object;

    /*
    **    Copy the parent location/size.
    **/
    position = *(( struct IBox * )&parent->LeftEdge );

    window_object = WindowObject,
        WINDOW_PosRelBox,        &position,
        ....
    EndObject;

    SEE ALSO
    WINDOW_Position

    NAME
    WINDOW_DragBar,         WINDOW_SizeGadget,       WINDOW_CloseGadget,
    WINDOW_DepthGadget -- ( BOOL )

    FUNCTION
    To switch on or off the corresponding system gadgets.

    Default for all are TRUE. Applicability is (I).

    NAME
    WINDOW_SizeBottom, WINDOW_SizeRight -- ( BOOL )

    FUNCTION
    To determine the place of the sizing gadget.

    Default is TRUE for bottom and FALSE for right. Applicability is (I).

    NAME
    WINDOW_Activate -- ( BOOL )

    FUNCTION
    To activate the window right after it is opened.

    Default is TRUE. Applicability is (I).

    NAME
    WINDOW_RMBTrap -- ( BOOL )

    FUNCTION
    To set/clear the WFLG_RMBTRAP  flag.  When set this disables the right
    from  activating  the  menu-strip.   It will also make the right mouse
    button visible in intuition events.

    Default is FALSE. Applicability is (I).

    NAME
    WINDOW_SmartRefresh -- ( BOOL )

    FUNCTION
    To set/clear the WFLG_SMART_REFRESH flag.

    Default is FALSE. Applicability is (I).

    NAME
    WINDOW_ReportMouse -- ( BOOL )

    FUNCTION
    To set/clear the WFLG_REPORTMOUSE flags.

    Default is FALSE. Applicability is (I).

    NAME
    WINDOW_IDCMP -- ( ULONG )

    FUNCTION
    To set extra IDCMP flags which are not automatically set by the window
    class  itself.    This  might  be  necessary  for  the  WINDOW_IDCMPHook
    described below.   The following  flags are  automatically set    by the
    window class:

    IDCMP_RAWKEY            - Key control of gadgets.
    IDCMP_GADGETUP            - The obvious.
    IDCMP_CHANGEWINDOW        - To track window changes.
    IDCMP_INACTIVEWINDOW        - To report window inactivation.
    IDCMP_ACTIVEWINDOW        - To report window activation.
    IDCMP_IDCMPUPDATE        - For WM_ADDUPDATE notification,
                      tab-cycling and continues slider and
                      scroller reporting.
    IDCMP_CLOSEWINDOW        - To report clicking the close gadget.
    IDCMP_MENUPICK            - To report menu-selections.
    IDCMP_SIZEVERIFY        - To handle user re-sizing.

    Please    note  that  IDCMP_VANILLAKEY  must  _not_  be set. The current
    keyboard handling does not allow this.

    Default is 0. Applicability is (I).

    SEE ALSO
    WINDOW_IDCMPHook, WINDOW_NoVerify

    NAME
    WINDOW_SharedPort -- ( struct MsgPort * )

    FUNCTION
    To use a shared message port for the window.  If you pass a pointer to
    a valid message port here the window will use this  port for receiving
    events.

    Default is NULL. Applicability is (I).

    NAME
    WINDOW_Title, WINDOW_ScreenTitle -- ( STRPTR )

    FUNCTION
    To set the window title and the title of  the screen  while the window
    is active.

    Defaults are NULL. Applicability is (ISU).

    NAME
    WINDOW_MenuStrip -- ( struct NewMenu * ) ( struct Menu * )

    FUNCTION
    This attribute has two data types to be considered.  Uppon creation of
    the  window  object  the  data    expected  is  a pointer to an array of
    NewMenu  structures  as  defined  in  <libraries/gadtools.h>. When you
    obtain    this  attribute  with  OM_GET  you  will  get a pointer to the
    created menus.

    To  make  the  menus  visible  to  your  program  you  must give every
    selectable  menu an ID. The ID must be placed in the nm_UserData field
    of the corresponding NewMenu structure.

    Example:

    #define ID_ABOUT    1
    #define ID_QUIT         2

    struct NewMenu Menus {
        { NM_TITLE,  "Project",   NULL, 0, 0, NULL },
        { NM_ITEM,   "About...",  "?",  0, 0, (APTR)ID_ABOUT },
        { NM_ITEM,   NM_BARLABEL, NULL, 0, 0, NULL },
        { NM_ITEM,   "Quit",      "Q",  0, 0, (APTR)ID_QUIT },
        { NM_END,    NULL,      NULL, 0, 0, NULL }
    }

    The  WM_HANDLEIDCMP  method  will  return ID_ABOUT when the "About..."
    item is selected and ID_QUIT when the "Quit" item is selected.

    Default is NULL. Applicability is (IG).

    NOTE: Since V38.6 of the library the windowclass will  make  a private
          copy of the passed NewMenu array.  The  strings of the items are
          NOT copied and must remain valid.

    NAME
    WINDOW_MasterGroup -- ( Object * )

    FUNCTION
    To  set  the master group containing all objects for the window.  This
    attribute   data   _must_  point  to a valid groupclass object or else
    the  window  object  creation     will     fail.     It's   currently  not
    possible   to    create     a  windowclass  object without a group object
    attached  to it. The data expected here is a pointer to the groupclass
    object    containing  all other gadget objects.

    Example:

    Object            *WO_Window;

    WO_Window = WindowObject,
        WINDOW_Title,        "Whatever",
        ...
        WINDOW_MasterGroup,
            HGroupObject, HOffset( 4 ), VOffset( 4 ),
                StartMember,
                    Button( "Quit", 0 ),
                EndMember,
            EndObject,
    EndObject;

    Default is NULL. Applicability is (I).

    NAME
    WINDOW_Screen -- ( struct Screen * )

    FUNCTION
    To set the custom screen on which the window should open.  If you want
    your  window  to  open on a custom screen you can pass a pointer to it
    here.  Please  note  that you  can use OM_SET to change this attribute
    only when the window is not open.

    NEW FOR V39
        Before    this  attribute  made  the mistake of using the screen
        with the WA_PubScreen attribute.  Now  it  makes  use  of  the
        WA_CustomScreen attribute.

    Default is NULL. Applicability is (IS).

    SEE ALSO
    WINDOW_PubScreen

    NAME
    WINDOW_PubScreenName -- ( STRPTR )

    FUNCTION
    To set the name of the public screen on which the window should  open.
    Please note that you can use  OM_SET  to change  this  attribute  only
    when the window is not open.

    Default is NULL (default public screen). Applicability is (IS).

    SEE ALSO
    WINDOW_Screen

    NAME
    WINDOW_UserPort -- ( struct MsgPort * )

    FUNCTION
    To obtain a pointer to the message port of the window.

    Applicability is (G).

    NAME
    WINDOW_SigMask -- ( ULONG )

    FUNCTION
    To  obtain  the  window signal mask.

    Example:

    Object           *WO_Win;
    ULONG        mask;

    GetAttr( WINDOW_SigMask, WO_Win, &mask );

    do {
        Wait( mask );
        ...
    } while ( ... );

    Applicability is (G).

    SEE ALSO
    WINDOW_AppMask

    NAME
    WINDOW_IDCMPHook, WINDOW_VerifyHook -- ( struct Hook * )

    FUNCTION
    To  tie  yourself  into  the IDCMP handling of the window.  With these
    attributes  you  can  set a hook which is called uppon    events set  by
    the  WINDOW_IDCMPHookBits and/or WINDOW_VerifyHookBits attributes. The
    hooks are called as follows:

    void hookRoutine( hook, object, imsg )
              A0    A2    A1

    struct Hook        *hook;
    Object            *object;
    struct IntuiMessage    *imsg;

    The  pointer  to  the  IntuiMessage  structure    is read-only. Also the
    message  is  passed to you before it is reply'd so you should not take
    to long before returning.

    The  IDCMPHook    is  called  after  the window object has done it's own
    processing on the message. The VerifyHook is called directly while the
    window object does not need to process any verification messages.

    Default is NULL. Applicability is (I).

    SEE ALSO
    WINDOW_IDCMP, WINDOW_IDCMPHookBits, WINDOW_VerifyHookBits

    NAME
    WINDOW_IDCMPHookBits, WINDOW_VerifyHookBits -- ( ULONG )

    FUNCTION
    To  set  the  bits  that  will cause the IDCMPHook or VerifyHook to be
    called.  The bits you pass here are the standard system IDCMP_xxx flag
    bits  found in <intuition/intuition.h>. Please note that some of these
    bits  require  you  to set them first using the WINDOW_IDCMP attribute
    described above.

    Example:

    struct Hook        *idcmp_hook;
    Object            *wd_obj;

    wd_obj = WindowObject,
        WINDOW_IDCMP,        IDCMP_INTUITICKS,
        WINDOW_IDCMPHook,    idcmp_hook,
        WINDOW_IDCMPHookBits,    IDCMP_INTUITICKS,
        ...
    EndObject;

    This   will   cause   the   WINDOW_IDCMPHook  to  be  called  at  each
    IDCMP_INTUITICKS event.

    Please note that the window class does not filter  out    any non-verify
    bits  from  the WINDOW_VerifyHookBits you pass. This means that if you
    set  IDCMP_GADGETUP  in  the  verification bits you will block out the
    window    object    event  handler    from  receiving  gadget  messages. The
    verification bits set should be restricted to the following bits:

    IDCMP_REQVERIFY
    IDCMP_MENUVERIFY

    Defaults are 0. Applicability is (I).

    SEE ALSO
    WINDOW_IDCMP, WINDOW_IDCMPHook, WINDOW_VerifyHook

    NAME
    WINDOW_Font -- ( struct TextAttr * )

    FUNCTION
    To  set the font to be used by the gadget objects. By default the font
    of  the  screen the window is opened on is used. With this tag you can
    select your own font.  Note that the font is opened with OpenFont() so
    please make sure it is present in memory.

    Default is NULL. Applicability is (I).

    SEE ALSO
    WINDOW_FallBackFont

    NAME
    WINDOW_FallBackFont -- ( struct TextAttr * )

    FUNCTION
    To  set the font to try whenever a window fails to open because it has
    grown  to big for the screen. By default the fallback font is topaz 8.
    If  you  pass a TextAttr here the window object will first try to fall
    back  to  the supplied font and, if that also fails, it will try topaz
    8. When topaz 8 fails the window will not open.  Note that the font is
    opened with OpenFont() so please make sure it is present in memory.

    Default is NULL. Applicability is (I).

    SEE ALSO
    WINDOW_Font

    NAME
    WINDOW_HelpFile -- ( STRPTR )

    FUNCTION
    Set the name of the file to be displayed when a  help-request  for the
    object arives. Please note that the full path-name must be given.

    Default is NULL. Applicability is (IS).

    SEE ALSO
    WINDOW_HelpNode, WINDOW_HelpLine

    NAME
    WINDOW_HelpNode -- ( STRPTR )

    FUNCTION
    Set the name of the node which is diplayed in the help window.

    Default is NULL. Applicability is (IS).

    SEE ALSO
    WINDOW_HelpFile, WINDOW_HelpLine

    NAME
    WINDOW_HelpLine - ( ULONG )

    FUNCTION
    Set the line number  from  which the  file is  displayed.  This may be
    useful if the help-file is not an AmigaGuide file.

    Default is 0. Applicability is (IS).

    SEE ALSO
    WINDOW_HelpFile, WINDOW_HelpNode

    NAME
    WINDOW_AppWindow -- ( BOOL )

    FUNCTION
    To make the window an AppWindow.

    Default is FALSE. Applicability is (I).

    SEE ALSO
    WINDOW_AppMask

    NAME
    WINDOW_AppMask -- ( ULONG )

    FUNCTION
    To  obtain  the app-window signal mask.

    Example:

    Object           *WO_Win;
    ULONG        mask;

    GetAttr( WINDOW_AppMask, WO_Win, &mask );

    do {
        Wait( mask );
        ...
    } while ( ... );

    Applicability is (G).

    SEE ALSO
    WINDOW_SigMask

    NAME
    WINDOW_UniqueID -- ( ULONG )

    FUNCTION
    To provide the window with an ID. The ID must be a 32bit integer which
    is  used  to  store  information on the window it's position and size.
    This  allows  you to close and dispose of the window object, re-create
    it  with the same ID, and the position and size of the window the last
    time it was open is still the same.

    This tag  tracks  the  complete window bounds but if you re-create and
    open your window with the WINDOW_PosRelBox tag specified only the size
    of the    window is re-stored. The size will remain the same as the last
    time the  window  was  open  but  the position will be adjusted to the
    bounds specified with the WINDOW_PosRelBox tag.

    The ID must be non-NULL.

    Default is 0 (no storage is done). Applicability is (I).

    SEE ALSO
    WINDOW_PosRelBox

    NAME
    WINDOW_Window -- ( struct Window * )

    FUNCTION
    To get a pointer to the window structure.  The pointer you get will be
    NULL if the window is not opened.

    Applicability is (G).

    NAME
    WINDOW_Bounds -- ( struct IBox * )

    FUNCTION
    To  enable  you  to pick the position and the size of the window. This
    attribute expects a pointer to a struct IBox in which the position and
    size are stored. The windowclass will check the values and adjust them
    if necessary. I.E. You cannot specify a size smaller than  the minimum
    possible size.    Query this attribute with  OM_GET to find  out exactly
    where the window is located and what it's size is.

    Querying this attribute with OM_GET is only  possible when  the window
    is open. To get this attribute with OM_GET you specify    a pointer to a
    struct IBox in the method.   The  class  will  write the bounds in the
    struct IBox.

    Please    note  that  this   attribute   overides  the  WINDOW_Position,
    WINDOW_ScaleWidth, WINDOW_ScaleHeight and WINDOW_PosRelBox attributes.

    Default is NULL. Applicability is (ISG).

    SEE ALSO
    WINDOW_Position, WINDOW_ScaleWidth, WINDOW_ScaleHeight,
    WINDOW_PosRelBox

    NAME
    WINDOW_HelpText -- ( STRPTR)

    FUNCTION
    To setup  a  text  which  will be displayed if the help-key is pressed
    while the  mouse  pointer  is located above the window. This attribute
    should be  used  to  attach small on-line help to the window. The text
    you specify will be shown in a small BGUI_RequestA() type of requester
    so you    must  make  sure  that    everything  fit's  nicely on a 600x200
    screen.

    The specified text may contain any of the infoclass command sequences.

    This   attribute  overides  the  WINDOW_HelpFile,  WINDOW_HelpNode and
    WINDOW_HelpLine attributes.

    Default is NULL. Applicability (IS).

    SEE ALSO
    WINDOW_HelpFile, WINDOW_HelpNode, WINDOW_HelpLine,
    infoclass/INFO_TextFormat, bgui.library/BGUI_RequestA()

    NAME
    WINDOW_NoBufferRP -- ( BOOL )

    FUNCTION
    When this attribute is    set to    TRUE the  windowclass  will  tell  the
    layout engine not to  setup a  buffer  RastPort  which    means that all
    rendering occures  on-screen.    This may be handy when you use objects
    which  take  some  time  to  render  like the colorwheel.gadget on 256
    colour screens.

    Default is FALSE. Applicability is (I).

    NAME
    WINDOW_AutoAspect -- ( BOOL )

    FUNCTION
    When this attribute is set the    windowclass  will  automatically  make
    aspect ratio dependant decisions  about the  resulting GUI.  Currently
    the only thing it does is selecting the frame  thickness.  Other stuff
    like spacing and offsets might be added in the future.

    Default is FALSE. Applicability is (I).

    NAME
    WINDOW_PubScreen -- ( struct Screen * ) ** V39 **

    FUNCTION
    To set the public screen on which the window should open.  If you want
    your  window  to  open on a public screen you can pass a pointer to it
    here.  Please  note  that you  can use OM_SET to change this attribute
    only when the window is not open.

    Default is NULL. Applicability is (IS).

    SEE ALSO
    WINDOW_Screen, WINDOW_PubScreenName

    NAME
    WINDOW_CloseOnEsc -- ( BOOL ) ** V39 **

    FUNCTION
    When set to TRUE the application will  get a  WMHI_CLOSEWINDOW    result
    from the WM_HANDLEIDCMP method when the user presses the ESC key.

    Default is FALSE. Applicability is (IS).

    NAME
    WINDOW_Borderless -- ( BOOL ) ** V39 **

    FUNCTION
    To create a window without any intuition broders. When this tag is set
    to TRUE all system gadgets like the closegadget, depth gadget etc. are
    cleared. Also the title of the window, if given, is ignored.

    It is advisable  to  supply  your master group with some sort of frame
    when you use this  attribute  because  otherwise  there is  no visible
    delineation (nice word stolen from the RKM ;)) from  the  rest    of the
    display.

    Default = FALSE. Applicability is (I).

    NAME
    WINDOW_Backdrop -- ( BOOL ) ** V39 **

    FUNCTION
    To  make the window fall behind all otherwindows. When this tag is set
    to TRUE the window will always be located behind the other  windows on
    the   screen.     This    attribute   also   automatically   set's   the
    WINDOW_Borderless tag to TRUE and it will resize the display to  cover
    the entire display.

    Default is FALSE. Applicability is (I).

    SEE ALSO
    WINDOW_Borderless, WINDOW_ShowTitle

    NAME
    WINDOW_ShowTitle -- ( BOOL ) ** V39 **

    FUNCTION
    When  this  tag  is  set to TRUE the screen title will be visible when
    the  WINDOW_Backdrop  tag was  set to TRUE.  Otherwise the window will
    overlap the screen title.

    Default is FALSE. Applicability is (I).

   SEE ALSO
    WINDOW_Backdrop

   NAME
    WINDOW_ActNext, WINDOW_ActPrev -- ( Object * ) ** V39 **

   FUNCTION
    These attributes are only useful when you are  writing    custom    gadget
    classes fo BGUI. You should use these attributes to activate  the BGUI
    tab cycling when necessary.  The  data    you  specify for this tag is a
    pointer to the object in question.

    When  you  offer  tab-cycling  in  your  gadgetclass  and the user has
    pressed the (shift)-tab key(s)    you  should  send  out    a notification
    message containing  at    least  the  GA_ID  attribute  and one of these
    attributes. When the windowclass event handler get's this attribute it
    will activate the next/previous gadget and notify the application.

    NAME
    WINDOW_NoVerify -- ( BOOL ) ** V39 **

    FUNCTION
    The windowclass depends on the IDCMP_SIZEVERIFY flag  to  handle  user
    re-sizing of the window.  As you know the xxxVERIFY  flags  are pretty
    dangourous and should be responded to as fast as possible.  If you are
    unable to call the WM_HANDLEIDCMP method fast or  you need  to do some
    DOS related things just set this tag to TRUE on the window object.

    This will turn off the IDCMP_SIZEVERIFY dependance  of the  window and
    allow you to do your thing.

    After  you  are  finished  with  the  DOS stuff and/or you are able to
    respond to signals again set it back to FALSE again.

    Applicability is (I).